//p5076

#include <iostream>
#include <algorithm>
#include <climits> // 用于 INT_MIN 和 INT_MAX

// 定义最大元素个数
const int maxsize = 100000;

class A {
public:
    int checka(int n);      // 查询n的排名 (小于n的元素个数 + 1)
    void inserta(int n);    // 插入一个数
    int checkb(int n);      // 查询排名为n的数
    int prev(int n);        // 查询前驱 (严格小于n的最大元素)
    int next(int n);        // 查询后继 (严格大于n的最小元素)

    A() : size(0) {}        // 构造函数

private:
    int l[maxsize]; // 存储元素的数组
    int size;       // 数组当前大小 (从0开始计数)
};

int main()
{
    // 主函数部分保持不变，负责输入和调用操作
    A a;
    int n; std::cin >> n;
    for (int i = 0; i < n; i ++)
    {
        int opnum; std::cin >> opnum;
        int num; std::cin >> num;
        if (opnum == 1) std::cout << a.checka(num) << std::endl;
        else if (opnum == 2) std::cout << a.checkb(num) << std::endl;
        else if (opnum == 3) std::cout << a.prev(num) << std::endl;
        else if (opnum == 4) std::cout << a.next(num) << std::endl;
        else if (opnum == 5) a.inserta(num);
        else std::cout << "ERROR" << std::endl;
    }
    return 0;
}

// 操作5：插入一个数
void A::inserta(int n)
{
    // 直接在数组末尾插入，size递增。O(1)
    this->l[this->size ++] = n;
}


// 操作1：查询n的排名
// 排名定义为：严格小于n的元素个数 + 1
int A::checka(int n)
{
    // !! 效率瓶颈：每次查询都进行 O(N log N) 排序 !!
    std::sort(this->l, this->l + this->size); 

    // 使用 C++ 标准库的二分查找，找到第一个 >= n 的元素位置
    // 'p' 指向数组中第一个大于等于 n 的元素
    int* p = std::lower_bound(this->l, this->l + this->size, n);
    
    // p - this->l 得到的是小于 n 的元素个数 (即排名 - 1)
    // 排名 = 小于 n 的元素个数 + 1
    return (p - this->l) + 1;
}

// 操作2：查询排名为n的数
int A::checkb(int n)
{
    // !! 效率瓶颈：每次查询都进行 O(N log N) 排序 !!
    std::sort(this->l, this->l + this->size);

    // 边界检查：排名从1开始，不能超过size
    if (n < 1 || n > this->size) {
        // 排名n超出范围，返回一个表示错误的特定值，这里用 0 或根据题意返回
        return 0; 
    }
    
    // 数组索引从0开始，排名n对应索引 n-1
    return this->l[n-1];
}

// 操作3：查询前驱 (严格小于n的最大元素)
int A::prev(int n)
{
    // !! 效率瓶颈：每次查询都进行 O(N log N) 排序 !!
    std::sort(this->l, this->l + this->size);

    // 使用 C++ 标准库的二分查找，找到第一个 >= n 的元素位置
    int* p = std::lower_bound(this->l, this->l + this->size, n);

    // 'p' 已经是第一个 >= n 的元素的位置。
    // p-1 指向的是最后一个 < n 的元素（即前驱）。
    // 检查 p 是否是数组的起始位置（即所有元素都 >= n），如果是则前驱不存在。
    if (p == this->l) {
        // 如果 p 是起始位置，说明没有元素严格小于 n，返回最小值表示没有前驱
        return -2147483647; // 相当于你原代码中的 -2147483647
    }

    // p-1 就是严格小于 n 的最大元素（前驱）
    return *(p - 1);
}

// 操作4：查询后继 (严格大于n的最小元素)
int A::next(int n)
{
    // !! 效率瓶颈：每次查询都进行 O(N log N) 排序 !!
    std::sort(this->l, this->l + this->size);

    // 使用 C++ 标准库的二分查找，找到第一个 > n 的元素位置
    int* p = std::upper_bound(this->l, this->l + this->size, n);

    // 检查 p 是否是数组的结束位置（即所有元素都 <= n），如果是则后继不存在。
    if (p == this->l + this->size) {
        // 如果 p 是结束位置，说明没有元素严格大于 n，返回最大值表示没有后继
        return INT_MAX; // 相当于你原代码中的 2147483647
    }

    // p 指向的就是严格大于 n 的最小元素（后继）
    return *p;
}